﻿
namespace GestionTaxesRiaApp.Web
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;


    // Implémente la logique d'application à l'aide du contexte DbGestionTaxesEntities.
    // TODO: ajoutez votre logique d'application à ces méthodes ou dans d'autres méthodes.
    // TODO: connectez l'authentification (Windows/ASP.NET Forms) et supprimez les marques de commentaire suivantes pour désactiver l'accès anonyme
    // Ajoutez également des rôles pour limiter l'accès, selon le cas.
    // [RequiresAuthentication]
    [EnableClientAccess()]
    public class GestionTaxesService : LinqToEntitiesDomainService<DbGestionTaxesEntities>
    {

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Fonction ».
        public IQueryable<Fonction> GetFonction()
        {
            return this.ObjectContext.Fonction;
        }
        public Fonction GetFonctionById(int id)
        {
           return this.ObjectContext.Fonction.SingleOrDefault(f => f.fon_Id == id);
        }

        public void InsertFonction(Fonction fonction)
        {
            if ((fonction.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(fonction, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Fonction.AddObject(fonction);
            }
        }

        public void UpdateFonction(Fonction currentFonction)
        {
            this.ObjectContext.Fonction.AttachAsModified(currentFonction, this.ChangeSet.GetOriginal(currentFonction));
        }

        public void DeleteFonction(Fonction fonction)
        {
            if ((fonction.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(fonction, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Fonction.Attach(fonction);
                this.ObjectContext.Fonction.DeleteObject(fonction);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Frequentation ».
        public IQueryable<Frequentation> GetFrequentation()
        {
            return this.ObjectContext.Frequentation;
        }
        public IQueryable<Frequentation> GetFrequentationsByProprietaireId(int id)
        {
            return this.ObjectContext.Frequentation.Where(c => c.fre_IdProprietaire == id);
        }

        public void InsertFrequentation(Frequentation frequentation)
        {
            if ((frequentation.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(frequentation, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Frequentation.AddObject(frequentation);
            }
        }

        public void UpdateFrequentation(Frequentation currentFrequentation)
        {
            this.ObjectContext.Frequentation.AttachAsModified(currentFrequentation, this.ChangeSet.GetOriginal(currentFrequentation));
        }

        public void DeleteFrequentation(Frequentation frequentation)
        {
            if ((frequentation.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(frequentation, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Frequentation.Attach(frequentation);
                this.ObjectContext.Frequentation.DeleteObject(frequentation);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Logement ».
        public IQueryable<Logement> GetLogement()
        {
            return this.ObjectContext.Logement;
        }
        public Logement GetLogementById(int id)
        {
            return this.ObjectContext.Logement.SingleOrDefault(c => c.log_Id == id);
        }
        public IQueryable<Logement> GetLogementsByProprietaireId(int id)
        {
            return this.ObjectContext.Logement.Where(c => c.log_IdProprietaire == id);
        }

        public void InsertLogement(Logement logement)
        {
            if ((logement.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(logement, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Logement.AddObject(logement);
            }
        }

        public void UpdateLogement(Logement currentLogement)
        {
            this.ObjectContext.Logement.AttachAsModified(currentLogement, this.ChangeSet.GetOriginal(currentLogement));
        }

        public void DeleteLogement(Logement logement)
        {
            if ((logement.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(logement, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Logement.Attach(logement);
                this.ObjectContext.Logement.DeleteObject(logement);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Proprietaire ».
        public IQueryable<Proprietaire> GetProprietaire()
        {
            return this.ObjectContext.Proprietaire;
        }
        public Proprietaire GetProprietaireById(int id)
        {
            return this.ObjectContext.Proprietaire.SingleOrDefault(c => c.pro_Id == id);
        }

        public void InsertProprietaire(Proprietaire proprietaire)
        {
            if ((proprietaire.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(proprietaire, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Proprietaire.AddObject(proprietaire);
            }
        }

        public void UpdateProprietaire(Proprietaire currentProprietaire)
        {
            this.ObjectContext.Proprietaire.AttachAsModified(currentProprietaire, this.ChangeSet.GetOriginal(currentProprietaire));
        }

        public void DeleteProprietaire(Proprietaire proprietaire)
        {
            if ((proprietaire.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(proprietaire, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Proprietaire.Attach(proprietaire);
                this.ObjectContext.Proprietaire.DeleteObject(proprietaire);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Reduction ».
        public IQueryable<Reduction> GetReduction()
        {
            return this.ObjectContext.Reduction;
        }
        public Reduction GetReductionById(int id)
        {
            return this.ObjectContext.Reduction.SingleOrDefault(c => c.red_Id == id);
        }

        public void InsertReduction(Reduction reduction)
        {
            if ((reduction.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(reduction, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Reduction.AddObject(reduction);
            }
        }

        public void UpdateReduction(Reduction currentReduction)
        {
            this.ObjectContext.Reduction.AttachAsModified(currentReduction, this.ChangeSet.GetOriginal(currentReduction));
        }

        public void DeleteReduction(Reduction reduction)
        {
            if ((reduction.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(reduction, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Reduction.Attach(reduction);
                this.ObjectContext.Reduction.DeleteObject(reduction);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Tarif ».
        public IQueryable<Tarif> GetTarif()
        {
            return this.ObjectContext.Tarif;
        }

        public Tarif GetTarifById(int id)
        {
            return this.ObjectContext.Tarif.SingleOrDefault(c => c.tar_Id == id);
        }

        public void InsertTarif(Tarif tarif)
        {
            if ((tarif.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tarif, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Tarif.AddObject(tarif);
            }
        }

        public void UpdateTarif(Tarif currentTarif)
        {
            this.ObjectContext.Tarif.AttachAsModified(currentTarif, this.ChangeSet.GetOriginal(currentTarif));
        }

        public void DeleteTarif(Tarif tarif)
        {
            if ((tarif.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(tarif, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Tarif.Attach(tarif);
                this.ObjectContext.Tarif.DeleteObject(tarif);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « Utilisateur ».
        public IQueryable<Utilisateur> GetUtilisateur()
        {
            return this.ObjectContext.Utilisateur;
        }
        public Utilisateur GetUtilisateurById(int id)
        {
            return this.ObjectContext.Utilisateur.SingleOrDefault(c => c.uti_Id == id);
        }
        public Utilisateur GetUtilisateurByLoginMotDePasse(String UtilisateurLogin, String UtilisateurMotDePasse)
        {
            return this.ObjectContext.Utilisateur.SingleOrDefault(c => c.uti_Login == UtilisateurLogin && c.uti_MotDePasse == UtilisateurMotDePasse);
        }
        public IQueryable<Utilisateur> GetUtilisateurProprietaire()
        {
            return this.ObjectContext.Utilisateur.Where(c => c.uti_IdFonction == 1); 
        }

        public void InsertUtilisateur(Utilisateur utilisateur)
        {
            if ((utilisateur.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(utilisateur, EntityState.Added);
            }
            else
            {
                this.ObjectContext.Utilisateur.AddObject(utilisateur);
            }
        }

        public void UpdateUtilisateur(Utilisateur currentUtilisateur)
        {
            this.ObjectContext.Utilisateur.AttachAsModified(currentUtilisateur, this.ChangeSet.GetOriginal(currentUtilisateur));
        }

        public void DeleteUtilisateur(Utilisateur utilisateur)
        {
            if ((utilisateur.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(utilisateur, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.Utilisateur.Attach(utilisateur);
                this.ObjectContext.Utilisateur.DeleteObject(utilisateur);
            }
        }
    }
}


